home *** CD-ROM | disk | FTP | other *** search
/ AMIGA-CD 2 / Amiga-CD - Volume 2.iso / ungepackte_daten / 1993 / 5 / 04b / funktionsplotter / fplotter.ampk / EGS / TXT / EGSBlit.def < prev    next >
Encoding:
Text File  |  1995-06-01  |  26.9 KB  |  638 lines
  1. |##########|
  2. |#MAGIC   #|BOPDMNIK
  3. |#PROJECT #|""
  4. |#PATHS   #|"EGSProject"
  5. |#FLAGS   #|xx---x--x---xxx-----------------
  6. |#USERSW  #|--------------------------------
  7. |#USERMASK#|--------------------------------
  8. |#SWITCHES#|x--x-x----------
  9. |##########|
  10. DEFINITION MODULE EGSBlit;
  11. |
  12. | 31.08.91 EBitMapPtr bei Unpack Image
  13. |
  14. |
  15. |  +---------------------------------------------------------------------+
  16. |  |                                                                     |##
  17. |  |                egsblit.library v0.4, © '91 StoneWare                |##
  18. |  |                    EXTENDED - GRAPHICS - STANDARD                   |##
  19. |  |                                                                     |##
  20. |  +---------------------------------------------------------------------+##
  21. |    #######################################################################
  22. |
  23. | Diese Library stellt grundlegende Zeichenfunktionen zur Verfügung.
  24. | Es handelt sich vor allem um jene Funktionen, die in einer späteren
  25. | Kartenversion durch einen Blitter implementiert werden können.
  26. |
  27. | Es sollten deshalb wenn immer möglich diese Funktionen verwendet werden.
  28. |
  29. | Sie bildet ausserdem die Basis auf der weitere Librarys wie EGSLayers,
  30. | EGSGfx und EGSIntui aufsitzen. Wird sie für eine völlig andere Karte
  31. | implementiert, laufen diese höheren Librarys uneingeschränkt.
  32. |
  33. | Programme, die sich ebenfalls daran halten sind somit sehr Zukunftssicher.
  34. |
  35. | Diese Library verzichtet zu gunsten der Geschwindigkeit auf jeglichen
  36. | Verwaltungsaufwand. Die meisten Funktionen liegen in einer Version
  37. | mit und ohne Clipping vor. Dieses Clipping ist sehr rudimentär, da es
  38. | sich auf nur ein Rechteck bezieht.
  39. |
  40. FROM Exec    IMPORT LibraryPtr;
  41. FROM System  IMPORT Regs,LONGSET;
  42. FROM EGS     IMPORT EBitMap,EBitMapPtr;
  43. |
  44. | ClipRect, ClipRectPtr
  45. |
  46. | Definition eines Clipping-Rechtecks. Die Werte verstehen sich inklusive.
  47. | Das Feld "next" ist für die EGSLayers library, und wird von EGSBlit völlig
  48. | ignoriert.
  49. |
  50. TYPE
  51.   ClipRectPtr = POINTER TO ClipRect;
  52.   ClipRect    = RECORD
  53.                   next   : ClipRectPtr;
  54.                   left,
  55.                   top,
  56.                   right,
  57.                   bottom : INTEGER;
  58.                 END;
  59. |
  60. | ColorTable, Image
  61. |
  62. | Häufig ist es nötig für Icons vorgegebene Images zu verwenden. Da diese in
  63. | verschiedenen Modi verschieden aufgebaut sind, werden diese in einem
  64. | allgemeinen BitPlane orientierten Verfahren gespeichert, und können je nach
  65. | Bedarf zu verschiedenen BitTiefen aufgeblasen werden.
  66. |
  67. | Dazu wird ein Feld mit Farbwerten mitgeliefert, in die das Bild gewandelt
  68. | werden soll.
  69. |
  70. |
  71.   ColorTablePtr= POINTER TO ColorTable;
  72.   ColorTable  = ARRAY OF LONGINT;
  73.  
  74.   Image       = RECORD
  75.                   width,
  76.                   height,
  77.                   depth   : INTEGER;
  78.                   planes  : ARRAY [0..7] OF ANYPTR;
  79.                 END;
  80. |
  81. | Wozu mag dieser Typ wohl gut sein ????
  82. |
  83.   CharPtr     = POINTER TO CHAR;
  84. |
  85. | ColorDes, ColorDesPtr
  86. |
  87. | Darstellungsbeschreibung für Textausgaben.
  88. |
  89. | ColorDes
  90. |  .front       : Vordergrundfarbe
  91. |  .back        : Hintergrundfarbe, falls transparent = FALSE
  92. |  .transparent : wenn "TRUE", kommt der Hintergrund durch
  93. |
  94.   ColorDesPtr = POINTER TO ColorDes;
  95.   ColorDes    = RECORD
  96.                   front,back  : LONGINT;
  97.                   transparent : BOOLEAN;
  98.                 END;
  99. |
  100. | ImageDesPtr, ImageDes
  101. |
  102. | Objektbeschreibung für "FillMask".
  103. |
  104. | ImageDes
  105. |   .colors   : Füllfarben
  106. |   .left,
  107. |   .top,
  108. |   .width,
  109. |   .height   : Begrenzung des Objekts.
  110. |
  111.   ImageDesPtr = POINTER TO ImageDes;
  112.   ImageDes    = RECORD
  113.                   colors  : ColorDes;
  114.                   left,
  115.                   top,
  116.                   width,
  117.                   height   : INTEGER;
  118.                 END;
  119. |
  120. | Polygon, PolygonPtr
  121. |
  122. | Beschreibung eines Polygons für PolygonFill. Die Größe des Arrays ist nicht
  123. | beschränkt.
  124. |
  125.   Polygon     = ARRAY OF RECORD x,y : INTEGER END;
  126.   PolygonPtr  = POINTER TO Polygon;
  127.  
  128. VAR
  129.   EGSBlitBase : LibraryPtr;
  130. |
  131. | PROCEDURE ReadPixel(map IN A0 : EBitMapPtr;
  132. |                     x   IN D0,
  133. |                     y   IN D1 : INTEGER):LONGINT;
  134. |
  135. | Auslesen der Farbe eines Bildschirmpunktes. Diese Routine wird durch einen
  136. | Blitter sicher nicht beschleunigt. Sie sollte aus Kompatibilitätsgründen
  137. | verwendet werden, wenn mehrere Bit-Tiefen verwendet werden, oder ohne
  138. | Änderungen an bestehender Software neuere Graphikkarten unterstützt werden
  139. | sollen.
  140. |
  141. | Für den 8 bzw. 24 Bit Modus empfehlen sich sicher direktere Techniken.
  142. |
  143. | Beispiel : Umwandeln eines Bildes im 24Bit-Modus in Schwarz-Weiß 8Bit
  144. |
  145. | PROCEDURE BlackWhite(src IN A0,dst IN A1 : EBitMapPtr);
  146. | TYPE
  147. |   RGB     = RECORD red,green,blue,pad : SHORTCARD END;
  148. |   RGBPtr  = POINTER TO RGB
  149. |   BytePtr = POINTER TO SHORTCARD;
  150. | VAR
  151. |   s   IN A2 : RGBPtr;
  152. |   d   IN A3 : BytePtr;
  153. |   x   IN D2,
  154. |   y   IN D3 : INTEGER;
  155. | BEGIN
  156. |   INC(src^.planes.lock);
  157. |   INC(dst^.planes.lock);
  158. |   s:=RGBPtr(src^.planes.dest+20);
  159. |   d:=BytePtr(dst^.planes.dest);
  160. |   FOR y:=src^.height-1 TO 0 BY -1 DO
  161. |     FOR x:=src^.width-1 TO 0 BY -1 DO
  162. |       d+^:=(INTEGER(s^.red  )*5+
  163. |             INTEGER(s^.green)*7+
  164. |             INTEGER(s^.blue )*4) DIV 16;
  165. |       INC(s,4);
  166. |     END
  167. |   END;
  168. |   DEC(src^.planes.lock);
  169. |   DEC(dst^.planes.lock);
  170. | END BlackWhite;
  171. |
  172. LIBRARY EGSBlitBase BY -30  PROCEDURE ReadPixel(map IN A0 : EBitMapPtr;
  173.                                                 x   IN D0,
  174.                                                 y   IN D1 : INTEGER):LONGINT;
  175. |
  176. | PROCEDURE WritePixel(map  IN A0 : EBitMapPtr;
  177. |                      c    IN D0 : LONGINT;
  178. |                      x    IN D1,
  179. |                      y    IN D2 : INTEGER;
  180. |                      mask IN D3 : LONGSET);
  181. |
  182. | Setzt einen Punkt in der angegebenen Farbe. Für die Verwendung gilt das
  183. | selbe wie bei ReadPixel.
  184. |
  185. LIBRARY EGSBlitBase BY -36  PROCEDURE WritePixel(map  IN A0 : EBitMapPtr;
  186.                                                  c    IN D0 : LONGINT;
  187.                                                  x    IN D1,
  188.                                                  y    IN D2 : INTEGER;
  189.                                                  mask IN D3 : LONGSET);
  190. |
  191. | PROCEDURE InvertPixel(map IN A0 : EBitMapPtr;
  192. |                       x   IN D0,
  193. |                       y   IN D1 : INTEGER);
  194. |
  195. | Invertiert einen Pixel. (siehe auch "ReadPixel");
  196. |
  197. LIBRARY EGSBlitBase BY -42  PROCEDURE InvertPixel(map IN A0 : EBitMapPtr;
  198.                                                   x   IN D0,
  199.                                                   y   IN D1 : INTEGER);
  200. |
  201. | PROCEDURE Draw(map  IN A0 : EBitMapPtr;
  202. |                c    IN D0 : LONGINT;
  203. |                x1   IN D1,
  204. |                y1   IN D2,
  205. |                x2   IN D3,
  206. |                y2   IN D4 : INTEGER;
  207. |                mask IN D5 : LONGSET);
  208. |
  209. | Zeichnet eine Linie von einem angegebenen Startpunkt zu einem Zielpunkt.
  210. | Die Routine verwendet einen Modifizierten Bressenham-Algorithmus, ist also
  211. | relativ schnell. Sie wir mit Sicherheit von einem Blitter übernommen, sollte
  212. | also auf jeden Fall verwendet werden.
  213. |
  214. | Diese Prozedur clipt nicht an den BitMap-Grenzen, ist dadurch aber etwas
  215. | schneller. Wird als Farbwert -1 angegeben, werden die Punkte unter der
  216. | Linie invertiert.
  217. |
  218. LIBRARY EGSBlitBase BY -48  PROCEDURE Draw(map  IN A0 : EBitMapPtr;
  219.                                            c    IN D0 : LONGINT;
  220.                                            x1   IN D1,
  221.                                            y1   IN D2,
  222.                                            x2   IN D3,
  223.                                            y2   IN D4 : INTEGER;
  224.                                            mask IN D5 : LONGSET);
  225. |
  226. | PROCEDURE DrawClipped(map  IN A0 : EBitMapPtr;
  227. |                       rect IN A1 : ClipRectPtr;
  228. |                       c    IN D0 : LONGINT;
  229. |                       x1   IN D1 : INTEGER;
  230. |                       y1   IN D2 : INTEGER;
  231. |                       x2   IN D3 : INTEGER;
  232. |                       y2   IN D4 : INTEGER;
  233. |                       mask IN D5 : LONGSET);
  234. |
  235. | Entspricht "Draw", mit der Ausnahme, daß die Linie anhand des "ClipRects"
  236. | geclipt wird. Besteht der zu clippende Bereich aus mehreren Rechtecken,
  237. | muß die Prozedur mehrfach aufgeufen werden.
  238. |
  239. | PROCEDURE DrawPolyClip(map  : EBitMapPtr;
  240. |                        rect : ClipRectPtr;
  241. |                        c    : LONGINT;
  242. |                        x1   : INTEGER;
  243. |                        y1   : INTEGER;
  244. |                        x2   : INTEGER;
  245. |                        y2   : INTEGER;
  246. | BEGIN
  247. |   WHILE rect#NIL DO
  248. |     DrawClipped(map,rect,c,x1,y1,x2,y2);
  249. |     rect:=rect^.next
  250. |   END;
  251. | END DrawPolyClip;
  252. |
  253. | Diese Technik funktioniert ebenfalls bei den meisten clippenden Prozeduren.
  254. |
  255. LIBRARY EGSBlitBase BY -54  PROCEDURE DrawClipped(map  IN A0 : EBitMapPtr;
  256.                                                   rect IN A1 : ClipRectPtr;
  257.                                                   c    IN D0 : LONGINT;
  258.                                                   x1   IN D1 : INTEGER;
  259.                                                   y1   IN D2 : INTEGER;
  260.                                                   x2   IN D3 : INTEGER;
  261.                                                   y2   IN D4 : INTEGER;
  262.                                                   mask IN D5 : LONGSET);
  263. |
  264. | PROCEDURE InvertRectangle(map     IN A0 : EBitMapPtr;
  265. |                           left    IN D0,
  266. |                           top     IN D1,
  267. |                           right   IN D2,
  268. |                           bottom  IN D3 : INTEGER);
  269. |
  270. | Invertiert die Umrandung eines Rechtecks. Sollte verwendet werden für
  271. | Verschiebeoperationen mit der Maus. Diese Prozedur wird von EGSIntui
  272. | benutzt.
  273. | Wird die Prozedur zweimal mit den selben Parametern aufgerufen, ändert
  274. | sich am Bild nichts.
  275. |
  276. LIBRARY EGSBlitBase BY -60  PROCEDURE InvertRectangle(map     IN A0 : EBitMapPtr;
  277.                                                       left    IN D0,
  278.                                                       top     IN D1,
  279.                                                       right   IN D2,
  280.                                                       bottom  IN D3 : INTEGER);
  281. |
  282. | PROCEDURE RectangleFill(map    IN A0 : EBitMapPtr;
  283. |                         c      IN D0 : LONGINT;
  284. |                         left   IN D1,
  285. |                         top    IN D2,
  286. |                         width  IN D3,
  287. |                         height IN D4 : INTEGER);
  288. |
  289. | Füllt ein Rechteck mit den angegebenen Koordinaten. Wir als Farbe "c" -1
  290. | angegeben, wird das Rechteck invertiert. Die Routine clipt nicht, ist dafür
  291. | aber etwas schneller.
  292. | Die Werte von "width" und "height" verstehen sich als wirkliche Breite in
  293. | Pixel, ein Rechteck mit einem Punkt hätte also width=height=1.
  294. |
  295. | Diese Prozedur wird totsicher durch einen Blitter ersetzt, sollte also auf
  296. | jeden Fall benutzt werden.
  297. |
  298. | Beispiel: Löschen des Bildschirms mit einem Farbwert
  299. |
  300. | PROCEDURE ClrScrn(scr : EScreenPtr;back : LONGINT);
  301. | BEGIN
  302. |   MouseOff(scr);
  303. |   WITH scr^.map AS map DO
  304. |     RectangleFill(map,back,0,0,map^.width,map^.height);
  305. |   END;
  306. |   MouseOn(scr);
  307. | END ClrScrn;
  308. |
  309. LIBRARY EGSBlitBase BY -66  PROCEDURE RectangleFill(map    IN A0 : EBitMapPtr;
  310.                                                     c      IN D0 : LONGINT;
  311.                                                     left   IN D1,
  312.                                                     top    IN D2,
  313.                                                     width  IN D3,
  314.                                                     height IN D4 : INTEGER;
  315.                                                     mask   IN D5 : LONGSET);
  316. |
  317. | PROCEDURE RectangleClipped(map    IN A0 : EBitMapPtr;
  318. |                            rect   IN A1 : ClipRectPtr;
  319. |                            c      IN D0 : LONGINT;
  320. |                            left   IN D1,
  321. |                            top    IN D2,
  322. |                            width  IN D3,
  323. |                            height IN D4 : INTEGER);
  324. |
  325. | Selbe Funktion wie "RectangleFill", nur clipt diese Prozedur anhand eines
  326. | ClipRects.
  327. |
  328. LIBRARY EGSBlitBase BY -72  PROCEDURE RectangleClipped(map    IN A0 : EBitMapPtr;
  329.                                                        rect   IN A1 : ClipRectPtr;
  330.                                                        c      IN D0 : LONGINT;
  331.                                                        left   IN D1,
  332.                                                        top    IN D2,
  333.                                                        width  IN D3,
  334.                                                        height IN D4 : INTEGER;
  335.                                                        mask   IN D5 : LONGSET);
  336. |
  337. | PROCEDURE Write(map   IN A0 : EBitMapPtr;
  338. |                 color IN A2 : ColorDesPtr;
  339. |                 x     IN D0,
  340. |                 y     IN D1 : INTEGER;
  341. |                 str   IN A3 : CharPtr;
  342. |                 len   IN D2 : INTEGER);
  343. |
  344. | Schreibt ein Textstück mit dem eingebauten Zeichensatz. Diese Routine
  345. | clipt nicht.
  346. |
  347. | Ausgaben mit dem eingebauten Zeichensatz sind wesentlich schneller, als solche
  348. | mit Amiga-Fonts (siehe EGSGfx), da die Routine extra darauf zugeschnitten ist.
  349. | Es handelt sich um einen 8x10-Punkte Bold nicht proportional Font.
  350. |
  351. | Falls ihre Programme viel Text verwenden, und keine besonderen Anforderungen
  352. | an den Zeichensatz gestellt werden, sollte dieser Font verwendet werden.
  353. |
  354. LIBRARY EGSBlitBase BY -78  PROCEDURE Write(map   IN A0 : EBitMapPtr;
  355.                                             color IN A2 : ColorDesPtr;
  356.                                             x     IN D0,
  357.                                             y     IN D1 : INTEGER;
  358.                                             str   IN A3 : CharPtr;
  359.                                             len   IN D2 : INTEGER;
  360.                                             mask  IN D3 : LONGSET);
  361. |
  362. | PROCEDURE WriteClipped(map   IN A0 : EBitMapPtr;
  363. |                        rect  IN A1 : ClipRectPtr;
  364. |                        color IN A2 : ColorDesPtr;
  365. |                        x     IN D0,
  366. |                        y     IN D1 : INTEGER;
  367. |                        str   IN A3 : CharPtr;
  368. |                        len   IN D2 : INTEGER);
  369. |
  370. | Wie Write, nur mit Clipping.
  371. |
  372. LIBRARY EGSBlitBase BY -84  PROCEDURE WriteClipped(map   IN A0 : EBitMapPtr;
  373.                                                    rect  IN A1 : ClipRectPtr;
  374.                                                    color IN A2 : ColorDesPtr;
  375.                                                    x     IN D0,
  376.                                                    y     IN D1 : INTEGER;
  377.                                                    str   IN A3 : CharPtr;
  378.                                                    len   IN D2 : INTEGER;
  379.                                                    mask  IN D3 : LONGSET);
  380. |
  381. | PROCEDURE CopyBitMap(src    IN A0,
  382. |                      dst    IN A1  : EBitMapPtr;
  383. |                      xs     IN D0,
  384. |                      ys     IN D1,
  385. |                      width  IN D2,
  386. |                      height IN D3,
  387. |                      xd     IN D4,
  388. |                      yd     IN D5  : INTEGER);
  389. |
  390. | Kopiert einen Ausschnitt aus einer Bitmap in eine andere. Die BitMaps
  391. | müssen die selbe Bit-Tiefe haben. Diese Routine clipt nicht. Sie wird sicher
  392. | durch einen Blitter ersetzt werden, sollte also auf jeden Fall verwendet
  393. | werden. "width" und "height" verstehen sich wie bei "RectangleFill".
  394. |
  395. | Beispiel: Sichern und wiederherstellen eines Bildschirmrechtecks:
  396. |
  397. | PROCEDURE Push(map : EBitMapPtr;x,y,w,h : INTEGER):EBitMapPtr;
  398. | VAR push : EBitMapPtr;
  399. | BEGIN
  400. |   New(push);
  401. |   IF AllocBitMap(push^,map^.width,map^.height,map^.depth,FALSE) THEN
  402. |     CopyBitMap(map,push,x,y,w,h,0,0);
  403. |   ELSE
  404. |     Dispose(push);  | setzt push:=NIL;
  405. |   END;
  406. |   RETURN push;
  407. | END Push;
  408. |
  409. | PROCEDURE Pop(push,map : EBitMapPtr;x,y : INTEGER);
  410. | BEGIN
  411. |   CopyBitMap(push,map,0,0,push^.width,push^.height,x,y);
  412. |   Dispose(push);
  413. | END Pop;
  414. |
  415. LIBRARY EGSBlitBase BY -90  PROCEDURE CopyBitMap(src    IN A0,
  416.                                                  dst    IN A1  : EBitMapPtr;
  417.                                                  xs     IN D0,
  418.                                                  ys     IN D1,
  419.                                                  width  IN D2,
  420.                                                  height IN D3,
  421.                                                  xd     IN D4,
  422.                                                  yd     IN D5  : INTEGER;
  423.                                                  mask   IN D6  : LONGSET);
  424. |
  425. | PROCEDURE CopyBitMapClipped(src    IN A0,
  426. |                             dst    IN A1  : EBitMapPtr;
  427. |                             rect   IN A2  : ClipRectPtr;
  428. |                             xs     IN D0,
  429. |                             ys     IN D1,
  430. |                             width  IN D2,
  431. |                             height IN D3,
  432. |                             xd     IN D4,
  433. |                             yd     IN D5  : INTEGER);
  434. |
  435. | Wie CopyBitMap, nur wird das Ziel durch ein Rechteck geclipt.
  436. |
  437. LIBRARY EGSBlitBase BY -96  PROCEDURE CopyBitMapClipped(src    IN A0,
  438.                                                         dst    IN A1  : EBitMapPtr;
  439.                                                         rect   IN A2  : ClipRectPtr;
  440.                                                         xs     IN D0,
  441.                                                         ys     IN D1,
  442.                                                         width  IN D2,
  443.                                                         height IN D3,
  444.                                                         xd     IN D4,
  445.                                                         yd     IN D5  : INTEGER;
  446.                                                         mask   IN D6  : LONGSET);
  447. |
  448. | PROCEDURE FillMask(mask    IN A0 : EBitMapPtr;
  449. |                    dst     IN A1 : EBitMapPtr;
  450. |                    pattern IN A2 : ImageDesPtr;
  451. |                    x       IN D0,
  452. |                    y       IN D1 : INTEGER);
  453. |
  454. | Füllt ein Rechteck einer BitMap durch ein Muster. Dieses Muster muß als
  455. | BitMap mit ein Bit Tiefe vorliegen. Es kann sowohl transparent als auch
  456. | mit Hintergrund gefüllt werden. Diese Routine clipt nicht. Sie wird sicher
  457. | durch eine Blitteroperation ersetzt, und sollte auf jeden Fall verwendet
  458. | werden.
  459. | Sie dient als Basisroutine für Amiga-Fonts und Area-Befehle.
  460. |
  461. LIBRARY EGSBlitBase BY -102 PROCEDURE FillMask(mask    IN A0 : EBitMapPtr;
  462.                                                dst     IN A1 : EBitMapPtr;
  463.                                                pattern IN A2 : ImageDesPtr;
  464.                                                x       IN D0,
  465.                                                y       IN D1 : INTEGER;
  466.                                                mask    IN D2 : LONGSET);
  467. |
  468. | PROCEDURE FillMaskClipped(mask    IN A0 : EBitMapPtr;
  469. |                           dst     IN A1 : EBitMapPtr;
  470. |                           pattern IN A2 : ImageDesPtr;
  471. |                           clip    IN A3 : ClipRectPtr;
  472. |                           x       IN D0,
  473. |                           y       IN D1 : INTEGER);
  474. |
  475. | Wie FillMask, nur wird das Ziel mit einem ClipRect geclipt.
  476. |
  477. LIBRARY EGSBlitBase BY -108 PROCEDURE FillMaskClipped(mask    IN A0 : EBitMapPtr;
  478.                                                       dst     IN A1 : EBitMapPtr;
  479.                                                       pattern IN A2 : ImageDesPtr;
  480.                                                       clip    IN A3 : ClipRectPtr;
  481.                                                       x       IN D0,
  482.                                                       y       IN D1 : INTEGER;
  483.                                                       mask    IN D2 : LONGSET);
  484. |
  485. | PROCEDURE UnpackImage(VAR dst    IN A0 : EBitMap;
  486. |                       VAR image  IN A1 : Image;
  487. |                           depth  IN D0 : INTEGER;
  488. |                       VAR colors IN A2 : ColorTable):BOOLEAN;
  489. |
  490. | Für viele Anwendungen (Icons, Images, Pattern oder Gadgets) ist es nötig
  491. | standardisierte Bilder zu haben, die auch bei verschiedenen Modi verwendet
  492. | werden können, ohne sie jedesmal neu definieren zu müssen.
  493. | Diese Routine erhält als Eingabe eine Bildbeschreibung in Form von
  494. | Bitplanes (so können auch einfach Amiga-Images konvertiert werden), und
  495. | eine Farbtabelle. Die Bitplanes müssen auf ganze Worte gerundet werden.
  496. | Die Routine erzeugt zunächst eine BitMap-Struktur mit der angegebenen Tiefe
  497. | und der Größe des Bildes. Danach werden die Farben aus der Farbtabelle
  498. | eingetragen, wie sie über die Bitplanes kodiert sind.
  499. |
  500. | Beispiel: Ein vierfarbiges "Smiley"
  501. |
  502. | CONST
  503. |   ImageA  = Image:(width=16,height=12,depth=2,planes=(
  504. |                    ARRAY OF CARDINAL:(%0000001111000000,
  505. |                                       %0001111111111000,
  506. |                                       %0011111111111100,
  507. |                                       %0111000110001110,
  508. |                                       %0111011111101110,
  509. |                                       %1111111111111111,
  510. |                                       %1111111111111111,
  511. |                                       %0111111111111110,
  512. |                                       %0111111111111110,
  513. |                                       %0011111111111100,
  514. |                                       %0001111111111000,
  515. |                                       %0000001111000000)'PTR,
  516. |                    ARRAY OF CARDINAL:(%0000001111000000,
  517. |                                       %0001110000111000,
  518. |                                       %0010000000000100,
  519. |                                       %0100111001110010,
  520. |                                       %0100111001110010,
  521. |                                       %1000000000000001,
  522. |                                       %1001110000111001,
  523. |                                       %0100111111110010,
  524. |                                       %0100011111100010,
  525. |                                       %0010000000000100,
  526. |                                       %0001110000111000,
  527. |                                       %0000001111000000)'PTR,
  528. |                    NIL,NIL,NIL,NIL,NIL,NIL));
  529. |
  530. | VAR map : VBitMap;
  531. |
  532. | ...
  533. |   IF UnpackImage(map,ImageA,24,ColorTable:($FF000000,  | rot
  534. |                                            $FFFFFF00,  | weiß
  535. |                                            $FFFF0000,  | gelb
  536. |                                            $00000000));| schwarz
  537. |     CopyBitMap(map,dest,0,0,map^.width,map^.height,100,100);
  538. |   END;
  539. | ...
  540. |
  541. |
  542. LIBRARY EGSBlitBase BY -114 PROCEDURE UnpackImage(VAR image  IN A1 : Image;
  543.                                                       depth  IN D0 : INTEGER;
  544.                                                       colors IN A2 : ColorTablePtr):EBitMapPtr;
  545. |
  546. | PROCEDURE BitAreaCircle(dst    IN A0 : EBitMapPtr;
  547. |                         radius IN D0 : INTEGER);
  548. |
  549. | Zeichnet einen ausgefüllten Kreis in einer BitMap mit Tiefe eins. Der
  550. | Kreis steht in der oberen linken Ecke. Die Daten der BitMap werden
  551. | so verbogen, daß sie den Kreis genau einhüllt.
  552. |
  553. | Der erzeugte Kreis kann als Vorlage für "FillMask" dienen.
  554. |
  555. LIBRARY EGSBlitBase BY -120 PROCEDURE BitAreaCircle(dst     IN A0 : EBitMapPtr;
  556.                                                     radius  IN D0 : INTEGER;
  557.                                                     xoffset IN D1 : INTEGER);
  558. |
  559. | PROCEDURE BitAreaPolygon(dst    IN A0 : EBitMapPtr;
  560. |                          poly   IN A1 : PolygonPtr;
  561. |                          range  IN D0 : INTEGER;
  562. |                          width  IN D1,
  563. |                          height IN D2 : INTEGER);
  564. |
  565. | Zeichnet ein ausgefülltes Polygon in eine einplaneige (sorry) BitMap. Das
  566. | Polygon sollte so normalisiert werden, daß die kleinsten Koordinaten in
  567. | x- und y-Richtung genau null sind.
  568. |
  569. | In "width" und "height" muß die echte Breite und Höhe des Polygons übergeben
  570. | werden, da die Ausmaße der BitMap daran angepasst werden.
  571. |
  572. | Das Poylgon wird als Array von Koordinaten übergeben, die Anzahl der Eckpunkte
  573. | in "range".
  574. |
  575. | Überlappen sich Teile des Polygons löschen sich diese gegenseitig aus, so daß
  576. | auch Teile freigelassen werden können (für Vector-Fonts etc.). Liegen die
  577. | beiden Ränder eine Strecke aufeinander, (Start- und Endpunkt beider
  578. | Begrenzungen sind gleich) wird nichts gezeichnet, so daß auch Enklaven
  579. | möglich sind.
  580. |
  581. | Diese Routine liefert Grundlagen für "FillMask".
  582. |
  583. LIBRARY EGSBlitBase BY -126 PROCEDURE BitAreaPolygon(dst    IN A0 : EBitMapPtr;
  584.                                                      poly   IN A1 : PolygonPtr;
  585.                                                      range  IN D0 : INTEGER;
  586.                                                      width  IN D1,
  587.                                                      height IN D2 : INTEGER);
  588. |
  589. | PROCEDURE FloodFill(dst   IN A0 : EBitMapPtr;
  590. |                     clip  IN A1 : ClipRectPtr;
  591. |                     color IN D0 : LONGINT;
  592. |                     x     IN D1,
  593. |                     y     IN D2 : INTEGER;
  594. |                     mode  IN D3 : BOOLEAN);
  595. |
  596. | Füllt ein zusammenhängendes Stück einer BitMap. Das angegebene ClipRect dient
  597. | als zusätzliche Grenze, falls der Bereich zum Rand hin offen ist.
  598. |
  599. | Ist mode=FALSE, wird der Bereich gefüllt, der die Farbe an der Startstelle
  600. | hat, sonst der Bereich, der durch die zu füllende Farbe umgeben ist.
  601. |
  602. | Leider ist es nicht möglich diese Routine auch für komplexe ClipRegions
  603. | zu benützen,
  604. |
  605. LIBRARY EGSBlitBase BY -132 PROCEDURE FloodFill(dst   IN A0 : EBitMapPtr;
  606.                                                 clip  IN A1 : ClipRectPtr;
  607.                                                 color IN D0 : LONGINT;
  608.                                                 x     IN D1,
  609.                                                 y     IN D2 : INTEGER;
  610.                                                 mode  IN D3 : BOOLEAN);
  611.  
  612.  
  613.  
  614. LIBRARY EGSBlitBase BY -138 PROCEDURE ExtractColor(src   IN A0,
  615.                                                    dst   IN A1  : EBitMapPtr;
  616.                                                    color IN D0  : LONGINT;
  617.                                                    sx    IN D1,
  618.                                                    sy    IN D2,
  619.                                                    w     IN D3,
  620.                                                    h     IN D4,
  621.                                                    dx    IN D5,
  622.                                                    dy    IN D6  : INTEGER);
  623.  
  624. LIBRARY EGSBlitBase BY -144 PROCEDURE FloodOneBit(map   IN A0 : EBitMapPtr;
  625.                                                   clip  IN A1,
  626.                                                   dclip IN A2 : ClipRectPtr;
  627.                                                   x     IN D0,
  628.                                                   y     IN D1 : INTEGER);
  629.  
  630. LIBRARY EGSBlitBase BY -150 PROCEDURE FloodZeroBit(map   IN A0 : EBitMapPtr;
  631.                                                    clip  IN A1,
  632.                                                    dclip IN A2 : ClipRectPtr;
  633.                                                    x     IN D0,
  634.                                                    y     IN D1 : INTEGER);
  635.  
  636. END EGSBlit.
  637.  
  638.